home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Resources / Chat & Communication / Digsby build 37 / digsby_setup.exe / lib / ZSI / TC.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2008-10-13  |  43.4 KB  |  1,559 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.5)
  3.  
  4. from ZSI import _copyright, _children, _child_elements, _floattypes, _stringtypes, _seqtypes, _find_attr, _find_attrNS, _find_attrNodeNS, _find_arraytype, _find_default_namespace, _find_href, _find_encstyle, _resolve_prefix, _find_xsi_attr, _find_type, _find_xmlns_prefix, _get_element_nsuri_name, _get_idstr, _Node, EvaluateException, UNICODE_ENCODING, _valid_encoding, ParseException
  5. from ZSI.wstools.Namespaces import SCHEMA, SOAP
  6. from ZSI.wstools.Utility import SplitQName
  7. from ZSI.wstools.c14n import Canonicalize
  8. from ZSI.wstools.logging import getLogger as _GetLogger
  9. import re
  10. import types
  11. import time
  12. import copy
  13. from base64 import decodestring as b64decode, encodestring as b64encode
  14. from urllib import unquote as urldecode, quote as urlencode
  15. from binascii import unhexlify as hexdecode, hexlify as hexencode
  16.  
  17. try:
  18.     from cStringIO import StringIO
  19. except ImportError:
  20.     from StringIO import StringIO
  21.  
  22.  
  23. _is_xsd_or_soap_ns = lambda ns: ns in [
  24. SCHEMA.XSD3,
  25. SOAP.ENC,
  26. SCHEMA.XSD1,
  27. SCHEMA.XSD2]
  28.  
  29. _find_nil = lambda E: if not _find_xsi_attr(E, 'null'):
  30. pass_find_xsi_attr(E, 'nil')
  31.  
  32. def _get_xsitype(pyclass):
  33.     if hasattr(pyclass, 'type') and type(pyclass.type) in _seqtypes:
  34.         return pyclass.type
  35.     elif hasattr(pyclass, 'type') and hasattr(pyclass, 'schema'):
  36.         return (pyclass.schema, pyclass.type)
  37.     
  38.     return (None, None)
  39.  
  40. Nilled = None
  41. UNBOUNDED = 'unbounded'
  42.  
  43. class TypeCode:
  44.     tag = None
  45.     type = (None, None)
  46.     typechecks = True
  47.     attribute_typecode_dict = None
  48.     logger = _GetLogger('ZSI.TC.TypeCode')
  49.     
  50.     def __init__(self, pname = None, aname = None, minOccurs = 1, maxOccurs = 1, nillable = False, typed = True, unique = True, pyclass = None, attrs_aname = '_attrs', **kw):
  51.         if type(pname) in _seqtypes:
  52.             (self.nspname, self.pname) = pname
  53.         else:
  54.             self.nspname = None
  55.             self.pname = pname
  56.         if self.pname:
  57.             self.pname = str(self.pname).split(':')[-1]
  58.         
  59.         if not aname:
  60.             pass
  61.         self.aname = self.pname
  62.         self.minOccurs = minOccurs
  63.         self.maxOccurs = maxOccurs
  64.         self.nillable = nillable
  65.         self.typed = typed
  66.         self.unique = unique
  67.         self.attrs_aname = attrs_aname
  68.         self.pyclass = pyclass
  69.         encoded = kw.get('encoded')
  70.         if encoded is not None:
  71.             self.nspname = kw['encoded']
  72.         
  73.  
  74.     
  75.     def parse(self, elt, ps):
  76.         raise EvaluateException('Unimplemented evaluation', ps.Backtrace(elt))
  77.  
  78.     
  79.     def serialize(self, elt, sw, pyobj, name = None, orig = None, **kw):
  80.         raise EvaluateException('Unimplemented evaluation', sw.Backtrace(elt))
  81.  
  82.     
  83.     def text_to_data(self, text, elt, ps):
  84.         raise EvaluateException('Unimplemented evaluation', ps.Backtrace(elt))
  85.  
  86.     
  87.     def serialize_as_nil(self, elt):
  88.         elt.setAttributeNS(SCHEMA.XSI3, 'nil', '1')
  89.  
  90.     
  91.     def SimpleHREF(self, elt, ps, tag):
  92.         if len(_children(elt)):
  93.             return elt
  94.         
  95.         href = _find_href(elt)
  96.         if not href:
  97.             if self.minOccurs is 0:
  98.                 return None
  99.             
  100.             raise EvaluateException('Required' + tag + ' missing', ps.Backtrace(elt))
  101.         
  102.         return ps.FindLocalHREF(href, elt, 0)
  103.  
  104.     
  105.     def get_parse_and_errorlist(self):
  106.         d = self.__class__.__dict__
  107.         parselist = d.get('parselist')
  108.         errorlist = d.get('errorlist')
  109.         if parselist and not errorlist:
  110.             errorlist = []
  111.             for t in parselist:
  112.                 if t[1] not in errorlist:
  113.                     errorlist.append(t[1])
  114.                     continue
  115.             
  116.             errorlist = ' or '.join(errorlist)
  117.             d['errorlist'] = errorlist
  118.         
  119.         return (parselist, errorlist)
  120.  
  121.     
  122.     def checkname(self, elt, ps):
  123.         (parselist, errorlist) = self.get_parse_and_errorlist()
  124.         (ns, name) = _get_element_nsuri_name(elt)
  125.         if ns == SOAP.ENC:
  126.             if parselist and (None, name) not in parselist and (ns, name) not in parselist:
  127.                 raise EvaluateException('Element mismatch (got %s wanted %s) (SOAP encoding namespace)' % (name, errorlist), ps.Backtrace(elt))
  128.             
  129.             return (ns, name)
  130.         
  131.         if self.nspname and ns != self.nspname:
  132.             raise EvaluateException('Element NS mismatch (got %s wanted %s)' % (ns, self.nspname), ps.Backtrace(elt))
  133.         
  134.         if self.pname and name != self.pname:
  135.             raise EvaluateException('Element Name mismatch (got %s wanted %s)' % (name, self.pname), ps.Backtrace(elt))
  136.         
  137.         return self.checktype(elt, ps)
  138.  
  139.     
  140.     def checktype(self, elt, ps):
  141.         typeName = _find_type(elt)
  142.         if typeName is None or typeName == '':
  143.             return (None, None)
  144.         
  145.         (prefix, typeName) = SplitQName(typeName)
  146.         uri = ps.GetElementNSdict(elt).get(prefix)
  147.         if uri is None:
  148.             uri = self.nspname
  149.         
  150.         (parselist, errorlist) = self.get_parse_and_errorlist()
  151.         if (not parselist and (uri, typeName) in parselist or _is_xsd_or_soap_ns(uri)) and (None, typeName) in parselist:
  152.             return (uri, typeName)
  153.         
  154.         raise EvaluateException('Type mismatch (%s namespace) (got %s wanted %s)' % (uri, typeName, errorlist), ps.Backtrace(elt))
  155.  
  156.     
  157.     def name_match(self, elt):
  158.         if self.pname == elt.localName:
  159.             pass
  160.         return self.nspname in [
  161.             None,
  162.             '',
  163.             elt.namespaceURI]
  164.  
  165.     
  166.     def nilled(self, elt, ps):
  167.         if _find_nil(elt) not in ('true', '1'):
  168.             return False
  169.         
  170.         if self.nillable is False:
  171.             raise EvaluateException('Non-nillable element is NIL', ps.Backtrace(elt))
  172.         
  173.         return True
  174.  
  175.     
  176.     def simple_value(self, elt, ps, mixed = False):
  177.         if not _valid_encoding(elt):
  178.             raise EvaluateException('Invalid encoding', ps.Backtrace(elt))
  179.         
  180.         c = _children(elt)
  181.         if mixed is False:
  182.             if len(c) == 0:
  183.                 raise EvaluateException('Value missing', ps.Backtrace(elt))
  184.             
  185.             for c_elt in c:
  186.                 if c_elt.nodeType == _Node.ELEMENT_NODE:
  187.                     raise EvaluateException('Sub-elements in value', ps.Backtrace(c_elt))
  188.                     continue
  189.             
  190.         
  191.         return [](_[1])
  192.  
  193.     
  194.     def parse_attributes(self, elt, ps):
  195.         if self.attribute_typecode_dict is None:
  196.             return None
  197.         
  198.         attributes = { }
  199.         for attr, what in self.attribute_typecode_dict.items():
  200.             namespaceURI = None
  201.             localName = attr
  202.             if type(attr) in _seqtypes:
  203.                 (namespaceURI, localName) = attr
  204.             
  205.             value = _find_attrNodeNS(elt, namespaceURI, localName)
  206.             self.logger.debug('Parsed Attribute (%s,%s) -- %s', namespaceURI, localName, value)
  207.             if value is None:
  208.                 continue
  209.             
  210.             attributes[attr] = what.text_to_data(value, elt, ps)
  211.         
  212.         return attributes
  213.  
  214.     
  215.     def set_attributes(self, el, pyobj):
  216.         if not hasattr(pyobj, self.attrs_aname):
  217.             return None
  218.         
  219.         if not isinstance(getattr(pyobj, self.attrs_aname), dict):
  220.             raise TypeError, 'pyobj.%s must be a dictionary of names and values' % self.attrs_aname
  221.         
  222.         for attr, value in getattr(pyobj, self.attrs_aname).items():
  223.             namespaceURI = None
  224.             localName = attr
  225.             if type(attr) in _seqtypes:
  226.                 (namespaceURI, localName) = attr
  227.             
  228.             what = None
  229.             if getattr(self, 'attribute_typecode_dict', None) is not None:
  230.                 what = self.attribute_typecode_dict.get(attr)
  231.                 if what is None and namespaceURI is None:
  232.                     what = self.attribute_typecode_dict.get(localName)
  233.                 
  234.             
  235.             if hasattr(value, 'typecode') and not isinstance(what, AnyType):
  236.                 if what is not None and not isinstance(value.typecode, what):
  237.                     raise EvaluateException, 'self-describing attribute must subclass %s' % what.__class__
  238.                 
  239.                 what = value.typecode
  240.             
  241.             self.logger.debug('attribute create -- %s', value)
  242.             if isinstance(what, QName):
  243.                 what.set_prefix(el, value)
  244.             
  245.             if what is None:
  246.                 value = str(value)
  247.             else:
  248.                 value = what.get_formatted_content(value)
  249.             el.setAttributeNS(namespaceURI, localName, value)
  250.         
  251.  
  252.     
  253.     def set_attribute_xsi_type(self, el, **kw):
  254.         if kw.get('typed', self.typed):
  255.             (namespaceURI, typeName) = kw.get('type', _get_xsitype(self))
  256.             if namespaceURI and typeName:
  257.                 self.logger.debug('attribute: (%s, %s)', namespaceURI, typeName)
  258.                 el.setAttributeType(namespaceURI, typeName)
  259.             
  260.         
  261.  
  262.     
  263.     def set_attribute_href(self, el, objid):
  264.         el.setAttributeNS(None, 'href', '#%s' % objid)
  265.  
  266.     
  267.     def set_attribute_id(self, el, objid):
  268.         if self.unique is False:
  269.             el.setAttributeNS(None, 'id', '%s' % objid)
  270.         
  271.  
  272.     
  273.     def get_name(self, name, objid):
  274.         if type(name) is tuple:
  275.             return name
  276.         
  277.         ns = self.nspname
  278.         if not name and self.pname:
  279.             pass
  280.         n = 'E' + objid
  281.         return (ns, n)
  282.  
  283.     
  284.     def has_attributes(self):
  285.         if self.attribute_typecode_dict is None:
  286.             return False
  287.         
  288.         return len(self.attribute_typecode_dict) > 0
  289.  
  290.  
  291.  
  292. class SimpleType(TypeCode):
  293.     empty_content = None
  294.     logger = _GetLogger('ZSI.TC.SimpleType')
  295.     
  296.     def parse(self, elt, ps):
  297.         self.checkname(elt, ps)
  298.         if len(_children(elt)) == 0:
  299.             href = _find_href(elt)
  300.             if not href:
  301.                 if self.nilled(elt, ps) is False:
  302.                     return self.text_to_data(self.empty_content, elt, ps)
  303.                 
  304.                 if self.nillable is True:
  305.                     return Nilled
  306.                 
  307.                 raise EvaluateException('Requiredstring missing', ps.Backtrace(elt))
  308.             
  309.             if href[0] != '#':
  310.                 return ps.ResolveHREF(href, self)
  311.             
  312.             elt = ps.FindLocalHREF(href, elt)
  313.             self.checktype(elt, ps)
  314.             if self.nilled(elt, ps):
  315.                 return Nilled
  316.             
  317.             if len(_children(elt)) == 0:
  318.                 v = self.empty_content
  319.             else:
  320.                 v = self.simple_value(elt, ps)
  321.         else:
  322.             v = self.simple_value(elt, ps)
  323.         pyobj = self.text_to_data(v, elt, ps)
  324.         if self.attribute_typecode_dict is not None:
  325.             attributes = self.parse_attributes(elt, ps)
  326.             if attributes:
  327.                 setattr(pyobj, self.attrs_aname, attributes)
  328.             
  329.         
  330.         return pyobj
  331.  
  332.     
  333.     def get_formatted_content(self, pyobj):
  334.         raise NotImplementedError, 'method get_formatted_content is not implemented'
  335.  
  336.     
  337.     def serialize_text_node(self, elt, sw, pyobj):
  338.         textNode = None
  339.         if pyobj is not None:
  340.             text = self.get_formatted_content(pyobj)
  341.             if type(text) not in _stringtypes:
  342.                 raise TypeError, 'pyobj must be a formatted string'
  343.             
  344.             textNode = elt.createAppendTextNode(text)
  345.         
  346.         return textNode
  347.  
  348.     
  349.     def serialize(self, elt, sw, pyobj, name = None, orig = None, **kw):
  350.         objid = _get_idstr(pyobj)
  351.         (ns, n) = self.get_name(name, objid)
  352.         el = elt.createAppendElement(ns, n)
  353.         if self.nillable is True and pyobj is Nilled:
  354.             self.serialize_as_nil(el)
  355.             return None
  356.         
  357.         self.set_attributes(el, pyobj)
  358.         if not self.unique:
  359.             pass
  360.         unique = kw.get('unique', False)
  361.         if unique is False:
  362.             if not orig:
  363.                 pass
  364.             if sw.Known(pyobj):
  365.                 self.set_attribute_href(el, objid)
  366.                 return None
  367.             
  368.         if kw.get('typed', self.typed) is True:
  369.             self.set_attribute_xsi_type(el, **kw)
  370.         
  371.         if self.unique is False:
  372.             self.set_attribute_id(el, objid)
  373.         
  374.         self.serialize_text_node(el, sw, pyobj)
  375.         return el
  376.  
  377.  
  378.  
  379. class Any(TypeCode):
  380.     logger = _GetLogger('ZSI.TC.Any')
  381.     parsemap = { }
  382.     serialmap = { }
  383.     
  384.     def __init__(self, pname = None, aslist = False, minOccurs = 0, unique = False, **kw):
  385.         TypeCode.__init__(self, pname, minOccurs = minOccurs, unique = unique, **kw)
  386.         self.aslist = aslist
  387.         self.kwargs = dict(aslist = aslist, unique = unique)
  388.         self.kwargs.update(kw)
  389.  
  390.     
  391.     def listify(self, v):
  392.         return dict(v)
  393.  
  394.     
  395.     def parse_into_dict_or_list(self, elt, ps):
  396.         c = _child_elements(elt)
  397.         count = len(c)
  398.         v = []
  399.         if count == 0:
  400.             href = _find_href(elt)
  401.             if not href:
  402.                 return v
  403.             
  404.             elt = ps.FindLocalHREF(href, elt)
  405.             self.checktype(elt, ps)
  406.             c = _child_elements(elt)
  407.             count = len(c)
  408.             if count == 0:
  409.                 return self.listify(v)
  410.             
  411.         
  412.         if self.nilled(elt, ps):
  413.             return Nilled
  414.         
  415.         for c_elt in c:
  416.             v.append((str(c_elt.localName), self.__class__(**self.kwargs).parse(c_elt, ps)))
  417.         
  418.         return self.listify(v)
  419.  
  420.     
  421.     def parse(self, elt, ps):
  422.         (ns, type) = self.checkname(elt, ps)
  423.         if not type and self.nilled(elt, ps):
  424.             return Nilled
  425.         
  426.         if len(_children(elt)) == 0:
  427.             href = _find_href(elt)
  428.             if not href:
  429.                 if self.minOccurs < 1:
  430.                     if _is_xsd_or_soap_ns(ns):
  431.                         parser = Any.parsemap.get((None, type))
  432.                         if parser:
  433.                             return parser.parse(elt, ps)
  434.                         
  435.                     
  436.                     if not (ns, type) == (SOAP.ENC, 'Array'):
  437.                         if not _find_arraytype(elt):
  438.                             pass
  439.                         if ''.endswith('[0]'):
  440.                             return []
  441.                         
  442.                     return None
  443.                 
  444.                 raise EvaluateException('Required Any missing', ps.Backtrace(elt))
  445.             
  446.             elt = ps.FindLocalHREF(href, elt)
  447.             (ns, type) = self.checktype(elt, ps)
  448.         
  449.         if not type and elt.namespaceURI == SOAP.ENC:
  450.             ns = SOAP.ENC
  451.             type = elt.localName
  452.         
  453.         if not type or (ns, type) == (SOAP.ENC, 'Array'):
  454.             if len(_child_elements(elt)) == 0:
  455.                 return self.simple_value(elt, ps)
  456.             
  457.             return self.parse_into_dict_or_list(elt, ps)
  458.         
  459.         parser = Any.parsemap.get((ns, type))
  460.         if not parser and _is_xsd_or_soap_ns(ns):
  461.             parser = Any.parsemap.get((None, type))
  462.         
  463.         if not parser:
  464.             raise EvaluateException("Any can't parse element", ps.Backtrace(elt))
  465.         
  466.         return parser.parse(elt, ps)
  467.  
  468.     
  469.     def get_formatted_content(self, pyobj):
  470.         tc = type(pyobj)
  471.         if tc == types.InstanceType:
  472.             tc = pyobj.__class__
  473.             if hasattr(pyobj, 'typecode'):
  474.                 serializer = pyobj.typecode
  475.             else:
  476.                 serializer = Any.serialmap.get(tc)
  477.             if not serializer:
  478.                 tc = (types.ClassType, pyobj.__class__.__name__)
  479.                 serializer = Any.serialmap.get(tc)
  480.             
  481.         else:
  482.             serializer = Any.serialmap.get(tc)
  483.             if not serializer and isinstance(pyobj, time.struct_time):
  484.                 gDateTime = gDateTime
  485.                 import ZSI.TCtimes
  486.                 serializer = gDateTime()
  487.             
  488.         if serializer:
  489.             return serializer.get_formatted_content(pyobj)
  490.         
  491.         raise EvaluateException, 'Failed to find serializer for pyobj %s' % pyobj
  492.  
  493.     
  494.     def serialize(self, elt, sw, pyobj, name = None, **kw):
  495.         if hasattr(pyobj, 'typecode') and pyobj.typecode is not self:
  496.             pyobj.typecode.serialize(elt, sw, pyobj, **kw)
  497.             return None
  498.         
  499.         objid = _get_idstr(pyobj)
  500.         (ns, n) = self.get_name(name, objid)
  501.         kw.setdefault('typed', self.typed)
  502.         tc = type(pyobj)
  503.         self.logger.debug('Any serialize -- %s', tc)
  504.         if tc in _seqtypes:
  505.             if self.aslist:
  506.                 array = elt.createAppendElement(ns, n)
  507.                 array.setAttributeType(SOAP.ENC, 'Array')
  508.                 array.setAttributeNS(self.nspname, 'SOAP-ENC:arrayType', 'xsd:anyType[' + str(len(pyobj)) + ']')
  509.                 for o in pyobj:
  510.                     serializer = getattr(o, 'typecode', Any(**self.kwargs))
  511.                     serializer.serialize(array, sw, o, name = 'element', **kw)
  512.                 
  513.             else:
  514.                 struct = elt.createAppendElement(ns, n)
  515.                 for o in pyobj:
  516.                     serializer = getattr(o, 'typecode', Any(**self.kwargs))
  517.                     serializer.serialize(struct, sw, o, **kw)
  518.                 
  519.             return None
  520.         
  521.         kw['name'] = (ns, n)
  522.         if tc == types.DictType:
  523.             el = elt.createAppendElement(ns, n)
  524.             parentNspname = self.nspname
  525.             self.nspname = None
  526.             for o, m in pyobj.items():
  527.                 if type(o) != types.StringType and type(o) != types.UnicodeType:
  528.                     raise Exception, 'Dictionary implementation requires keys to be of type string (or unicode).' % pyobj
  529.                 
  530.                 kw['name'] = o
  531.                 kw.setdefault('typed', True)
  532.                 self.serialize(el, sw, m, **kw)
  533.             
  534.             self.nspname = parentNspname
  535.             return None
  536.         
  537.         if tc == types.InstanceType:
  538.             tc = pyobj.__class__
  539.             if hasattr(pyobj, 'typecode'):
  540.                 serializer = pyobj.typecode
  541.             else:
  542.                 serializer = Any.serialmap.get(tc)
  543.             if not serializer:
  544.                 tc = (types.ClassType, pyobj.__class__.__name__)
  545.                 serializer = Any.serialmap.get(tc)
  546.             
  547.         else:
  548.             serializer = Any.serialmap.get(tc)
  549.             if not serializer and isinstance(pyobj, time.struct_time):
  550.                 gDateTime = gDateTime
  551.                 import ZSI.TCtimes
  552.                 serializer = gDateTime()
  553.             
  554.         if not serializer:
  555.             if pyobj is None:
  556.                 self.serialize_as_nil(elt.createAppendElement(ns, n))
  557.             elif type(pyobj) != types.InstanceType:
  558.                 raise EvaluateException("Any can't serialize " + repr(pyobj))
  559.             else:
  560.                 self.serialize(elt, sw, pyobj.__dict__, **kw)
  561.         else:
  562.             tag = getattr(serializer, 'tag', None)
  563.             if self.pname is not None:
  564.                 if 'typed' not in kw:
  565.                     kw['typed'] = False
  566.                 
  567.             elif tag:
  568.                 if tag.find(':') == -1:
  569.                     tag = 'SOAP-ENC:' + tag
  570.                 
  571.                 kw['name'] = tag
  572.                 kw['typed'] = False
  573.             
  574.             serializer.unique = self.unique
  575.             serializer.serialize(elt, sw, pyobj, **kw)
  576.  
  577.  
  578.  
  579. class String(SimpleType):
  580.     empty_content = ''
  581.     parselist = [
  582.         (None, 'string')]
  583.     seriallist = [
  584.         types.StringType,
  585.         types.UnicodeType]
  586.     type = (SCHEMA.XSD3, 'string')
  587.     logger = _GetLogger('ZSI.TC.String')
  588.     
  589.     def __init__(self, pname = None, strip = True, **kw):
  590.         TypeCode.__init__(self, pname, **kw)
  591.         if kw.has_key('resolver'):
  592.             self.resolver = kw['resolver']
  593.         
  594.         self.strip = strip
  595.  
  596.     
  597.     def text_to_data(self, text, elt, ps):
  598.         if self.strip:
  599.             text = text.strip()
  600.         
  601.         if self.pyclass is not None:
  602.             return self.pyclass(text.encode(UNICODE_ENCODING))
  603.         
  604.         return text.encode(UNICODE_ENCODING)
  605.  
  606.     
  607.     def get_formatted_content(self, pyobj):
  608.         if type(pyobj) not in _stringtypes:
  609.             pyobj = str(pyobj)
  610.         
  611.         if type(pyobj) == unicode:
  612.             return pyobj.encode(UNICODE_ENCODING)
  613.         
  614.         return pyobj
  615.  
  616.  
  617.  
  618. class URI(String):
  619.     parselist = [
  620.         (None, 'anyURI'),
  621.         (SCHEMA.XSD3, 'anyURI')]
  622.     type = (SCHEMA.XSD3, 'anyURI')
  623.     logger = _GetLogger('ZSI.TC.URI')
  624.     reserved = ';/?:@&=+$,'
  625.     
  626.     def text_to_data(self, text, elt, ps):
  627.         return String.text_to_data(self, urldecode(text), elt, ps)
  628.  
  629.     
  630.     def get_formatted_content(self, pyobj):
  631.         u = urlencode(pyobj, self.reserved)
  632.         return String.get_formatted_content(self, u)
  633.  
  634.  
  635.  
  636. class QName(String):
  637.     parselist = [
  638.         (None, 'QName')]
  639.     type = (SCHEMA.XSD3, 'QName')
  640.     logger = _GetLogger('ZSI.TC.QName')
  641.     
  642.     def __init__(self, pname = None, strip = 1, **kw):
  643.         String.__init__(self, pname, strip, **kw)
  644.         self.prefix = None
  645.  
  646.     
  647.     def get_formatted_content(self, pyobj):
  648.         value = pyobj
  649.         if isinstance(pyobj, tuple):
  650.             (namespaceURI, localName) = pyobj
  651.             if self.prefix is not None:
  652.                 value = '%s:%s' % (self.prefix, localName)
  653.             
  654.         
  655.         return String.get_formatted_content(self, value)
  656.  
  657.     
  658.     def set_prefix(self, elt, pyobj):
  659.         if isinstance(pyobj, tuple):
  660.             (namespaceURI, localName) = pyobj
  661.             self.prefix = elt.getPrefix(namespaceURI)
  662.         
  663.  
  664.     
  665.     def text_to_data(self, text, elt, ps):
  666.         (prefix, localName) = SplitQName(text)
  667.         nsdict = ps.GetElementNSdict(elt)
  668.         if not prefix:
  669.             pass
  670.         prefix = ''
  671.         
  672.         try:
  673.             namespaceURI = nsdict[prefix]
  674.         except KeyError:
  675.             ex = None
  676.             raise EvaluateException('cannot resolve prefix(%s)' % prefix, ps.Backtrace(elt))
  677.  
  678.         v = (namespaceURI, localName)
  679.         if self.pyclass is not None:
  680.             return self.pyclass(v)
  681.         
  682.         return v
  683.  
  684.     
  685.     def serialize_text_node(self, elt, sw, pyobj):
  686.         self.set_prefix(elt, pyobj)
  687.         return String.serialize_text_node(self, elt, sw, pyobj)
  688.  
  689.  
  690.  
  691. class Token(String):
  692.     parselist = [
  693.         (None, 'token')]
  694.     type = (SCHEMA.XSD3, 'token')
  695.     logger = _GetLogger('ZSI.TC.Token')
  696.  
  697.  
  698. class Base64String(String):
  699.     parselist = [
  700.         (None, 'base64Binary'),
  701.         (SOAP.ENC, 'base64')]
  702.     type = (SOAP.ENC, 'base64')
  703.     logger = _GetLogger('ZSI.TC.Base64String')
  704.     
  705.     def text_to_data(self, text, elt, ps):
  706.         val = b64decode(text.replace(' ', '').replace('\n', '').replace('\r', ''))
  707.         if self.pyclass is not None:
  708.             return self.pyclass(val)
  709.         
  710.         return val
  711.  
  712.     
  713.     def get_formatted_content(self, pyobj):
  714.         pyobj = '\n' + b64encode(pyobj)
  715.         return String.get_formatted_content(self, pyobj)
  716.  
  717.  
  718.  
  719. class Base64Binary(String):
  720.     parselist = [
  721.         (None, 'base64Binary')]
  722.     type = (SCHEMA.XSD3, 'base64Binary')
  723.     logger = _GetLogger('ZSI.TC.Base64Binary')
  724.     
  725.     def text_to_data(self, text, elt, ps):
  726.         val = b64decode(text)
  727.         if self.pyclass is not None:
  728.             return self.pyclass(val)
  729.         
  730.         return val
  731.  
  732.     
  733.     def get_formatted_content(self, pyobj):
  734.         pyobj = b64encode(pyobj).strip()
  735.         return pyobj
  736.  
  737.  
  738.  
  739. class HexBinaryString(String):
  740.     parselist = [
  741.         (None, 'hexBinary')]
  742.     type = (SCHEMA.XSD3, 'hexBinary')
  743.     logger = _GetLogger('ZSI.TC.HexBinaryString')
  744.     
  745.     def text_to_data(self, text, elt, ps):
  746.         val = hexdecode(text)
  747.         if self.pyclass is not None:
  748.             return self.pyclass(val)
  749.         
  750.         return val
  751.  
  752.     
  753.     def get_formatted_content(self, pyobj):
  754.         pyobj = hexencode(pyobj).upper()
  755.         return String.get_formatted_content(self, pyobj)
  756.  
  757.  
  758.  
  759. class XMLString(String):
  760.     logger = _GetLogger('ZSI.TC.XMLString')
  761.     
  762.     def __init__(self, pname = None, readerclass = None, **kw):
  763.         String.__init__(self, pname, **kw)
  764.         self.readerclass = readerclass
  765.  
  766.     
  767.     def parse(self, elt, ps):
  768.         if not self.readerclass:
  769.             PyExpat = PyExpat
  770.             import xml.dom.ext.reader
  771.             self.readerclass = PyExpat.Reader
  772.         
  773.         v = String.parse(self, elt, ps)
  774.         return self.readerclass().fromString(v)
  775.  
  776.     
  777.     def get_formatted_content(self, pyobj):
  778.         return String.get_formatted_content(self, pyobj)
  779.  
  780.  
  781.  
  782. class Enumeration(String):
  783.     logger = _GetLogger('ZSI.TC.Enumeration')
  784.     
  785.     def __init__(self, choices, pname = None, **kw):
  786.         String.__init__(self, pname, **kw)
  787.         t = type(choices)
  788.         if t in _seqtypes:
  789.             self.choices = tuple(choices)
  790.         elif TypeCode.typechecks:
  791.             raise TypeError('Enumeration choices must be list or sequence, not ' + str(t))
  792.         
  793.         if TypeCode.typechecks:
  794.             for c in self.choices:
  795.                 if type(c) not in _stringtypes:
  796.                     raise TypeError('Enumeration choice ' + str(c) + ' is not a string')
  797.                     continue
  798.             
  799.         
  800.  
  801.     
  802.     def parse(self, elt, ps):
  803.         val = String.parse(self, elt, ps)
  804.         if val not in self.choices:
  805.             raise EvaluateException('Value not in enumeration list', ps.Backtrace(elt))
  806.         
  807.         return val
  808.  
  809.     
  810.     def serialize(self, elt, sw, pyobj, name = None, orig = None, **kw):
  811.         if pyobj not in self.choices:
  812.             raise EvaluateException('Value not in enumeration list', sw.Backtrace(elt))
  813.         
  814.         String.serialize(self, elt, sw, pyobj, name = name, orig = orig, **kw)
  815.  
  816.  
  817. _ignored = []
  818.  
  819. class Integer(SimpleType):
  820.     ranges = {
  821.         'unsignedByte': (0, 255),
  822.         'unsignedShort': (0, 65535),
  823.         'unsignedInt': (0, 0xFFFFFFFFL),
  824.         'unsignedLong': (0, 0xFFFFFFFFFFFFFFFFL),
  825.         'byte': (-128, 127),
  826.         'short': (-32768, 32767),
  827.         'int': (-0x80000000L, 2147483647),
  828.         'long': (-0x8000000000000000L, 0x7FFFFFFFFFFFFFFFL),
  829.         'negativeInteger': (_ignored, -1),
  830.         'nonPositiveInteger': (_ignored, 0),
  831.         'nonNegativeInteger': (0, _ignored),
  832.         'positiveInteger': (1, _ignored),
  833.         'integer': (_ignored, _ignored) }
  834.     parselist = [ (None, k) for k in ranges.keys() ]
  835.     seriallist = [
  836.         types.IntType,
  837.         types.LongType]
  838.     logger = _GetLogger('ZSI.TC.Integer')
  839.     
  840.     def __init__(self, pname = None, format = '%d', **kw):
  841.         TypeCode.__init__(self, pname, **kw)
  842.         self.format = format
  843.  
  844.     
  845.     def text_to_data(self, text, elt, ps):
  846.         if self.pyclass is not None:
  847.             v = self.pyclass(text)
  848.         else:
  849.             
  850.             try:
  851.                 v = int(text)
  852.             except:
  853.                 
  854.                 try:
  855.                     v = long(text)
  856.                 raise EvaluateException('Unparseable integer', ps.Backtrace(elt))
  857.  
  858.  
  859.         return v
  860.  
  861.     
  862.     def parse(self, elt, ps):
  863.         (ns, type) = self.checkname(elt, ps)
  864.         if self.nilled(elt, ps):
  865.             return Nilled
  866.         
  867.         elt = self.SimpleHREF(elt, ps, 'integer')
  868.         if not elt:
  869.             return None
  870.         
  871.         if type is None:
  872.             type = self.type[1]
  873.         elif self.type[1] is not None and type != self.type[1]:
  874.             raise EvaluateException('Integer type mismatch; got %s wanted %s' % (type, self.type[1]), ps.Backtrace(elt))
  875.         
  876.         v = self.simple_value(elt, ps)
  877.         v = self.text_to_data(v, elt, ps)
  878.         (rmin, rmax) = Integer.ranges.get(type, (_ignored, _ignored))
  879.         if rmin != _ignored and v < rmin:
  880.             raise EvaluateException('Underflow, less than ' + repr(rmin), ps.Backtrace(elt))
  881.         
  882.         if rmax != _ignored and v > rmax:
  883.             raise EvaluateException('Overflow, greater than ' + repr(rmax), ps.Backtrace(elt))
  884.         
  885.         return v
  886.  
  887.     
  888.     def get_formatted_content(self, pyobj):
  889.         return self.format % pyobj
  890.  
  891.  
  892.  
  893. def _make_inf():
  894.     x = 2
  895.     x2 = x * x
  896.     i = 0
  897.     while i < 100 and x != x2:
  898.         x = x2
  899.         x2 = x * x
  900.         i = i + 1
  901.     if x != x2:
  902.         raise ValueError("This machine's floats go on forever!")
  903.     
  904.     return x
  905.  
  906. _magicnums = { }
  907.  
  908. try:
  909.     _magicnums['INF'] = float('INF')
  910.     _magicnums['-INF'] = float('-INF')
  911. except:
  912.     _magicnums['INF'] = _make_inf()
  913.     _magicnums['-INF'] = -_magicnums['INF']
  914.  
  915.  
  916. def isnan(x):
  917.     if x * 1 < x:
  918.         return 1
  919.     
  920.     if 1 == x:
  921.         pass
  922.     return x == 2
  923.  
  924.  
  925. class Decimal(SimpleType):
  926.     parselist = [
  927.         (None, 'decimal'),
  928.         (None, 'float'),
  929.         (None, 'double')]
  930.     seriallist = _floattypes
  931.     type = None
  932.     ranges = {
  933.         'float': (7.00649e-46, -3.40282e+38, 3.40282e+38),
  934.         'double': (0, -1.79769e+308, 1.79769e+308) }
  935.     zeropat = re.compile('[1-9]')
  936.     logger = _GetLogger('ZSI.TC.Decimal')
  937.     
  938.     def __init__(self, pname = None, format = '%f', **kw):
  939.         TypeCode.__init__(self, pname, **kw)
  940.         self.format = format
  941.  
  942.     
  943.     def text_to_data(self, text, elt, ps):
  944.         v = text
  945.         if self.pyclass is not None:
  946.             return self.pyclass(v)
  947.         
  948.         m = _magicnums.get(v)
  949.         if m:
  950.             return m
  951.         
  952.         
  953.         try:
  954.             return float(v)
  955.         except:
  956.             raise EvaluateException('Unparseable floating point number', ps.Backtrace(elt))
  957.  
  958.  
  959.     
  960.     def parse(self, elt, ps):
  961.         (ns, type) = self.checkname(elt, ps)
  962.         elt = self.SimpleHREF(elt, ps, 'floating-point')
  963.         if not elt:
  964.             return None
  965.         
  966.         tag = getattr(self.__class__, 'type')
  967.         if tag:
  968.             if type is None:
  969.                 type = tag
  970.             elif tag != (ns, type):
  971.                 raise EvaluateException('Floating point type mismatch; got (%s,%s) wanted %s' % (ns, type, tag), ps.Backtrace(elt))
  972.             
  973.         
  974.         if self.nilled(elt, ps):
  975.             return Nilled
  976.         
  977.         v = self.simple_value(elt, ps)
  978.         
  979.         try:
  980.             fp = self.text_to_data(v, elt, ps)
  981.         except EvaluateException:
  982.             ex = None
  983.             ex.args.append(ps.Backtrace(elt))
  984.             raise ex
  985.  
  986.         m = _magicnums.get(v)
  987.         if m:
  988.             return m
  989.         
  990.         if str(fp).lower() in ('inf', '-inf', 'nan', '-nan'):
  991.             raise EvaluateException('Floating point number parsed as "' + str(fp) + '"', ps.Backtrace(elt))
  992.         
  993.         if fp == 0 and Decimal.zeropat.search(v):
  994.             raise EvaluateException('Floating point number parsed as zero', ps.Backtrace(elt))
  995.         
  996.         (rtiny, rneg, rpos) = Decimal.ranges.get(type, (None, None, None))
  997.         if rneg and fp < 0 and fp < rneg:
  998.             raise EvaluateException('Negative underflow', ps.Backtrace(elt))
  999.         
  1000.         if rtiny and fp > 0 and fp < rtiny:
  1001.             raise EvaluateException('Positive underflow', ps.Backtrace(elt))
  1002.         
  1003.         if rpos and fp > 0 and fp > rpos:
  1004.             raise EvaluateException('Overflow', ps.Backtrace(elt))
  1005.         
  1006.         return fp
  1007.  
  1008.     
  1009.     def get_formatted_content(self, pyobj):
  1010.         if pyobj == _magicnums['INF']:
  1011.             return 'INF'
  1012.         elif pyobj == _magicnums['-INF']:
  1013.             return '-INF'
  1014.         elif isnan(pyobj):
  1015.             return 'NaN'
  1016.         else:
  1017.             return self.format % pyobj
  1018.  
  1019.  
  1020.  
  1021. class Boolean(SimpleType):
  1022.     parselist = [
  1023.         (None, 'boolean')]
  1024.     seriallist = [
  1025.         bool]
  1026.     type = (SCHEMA.XSD3, 'boolean')
  1027.     logger = _GetLogger('ZSI.TC.Boolean')
  1028.     
  1029.     def text_to_data(self, text, elt, ps):
  1030.         v = text
  1031.         if v == 'false':
  1032.             if self.pyclass is None:
  1033.                 return False
  1034.             
  1035.             return self.pyclass(False)
  1036.         
  1037.         if v == 'true':
  1038.             if self.pyclass is None:
  1039.                 return True
  1040.             
  1041.             return self.pyclass(True)
  1042.         
  1043.         
  1044.         try:
  1045.             v = int(v)
  1046.         except:
  1047.             
  1048.             try:
  1049.                 v = long(v)
  1050.             raise EvaluateException('Unparseable boolean', ps.Backtrace(elt))
  1051.  
  1052.  
  1053.         if v:
  1054.             if self.pyclass is None:
  1055.                 return True
  1056.             
  1057.             return self.pyclass(True)
  1058.         
  1059.         if self.pyclass is None:
  1060.             return False
  1061.         
  1062.         return self.pyclass(False)
  1063.  
  1064.     
  1065.     def parse(self, elt, ps):
  1066.         self.checkname(elt, ps)
  1067.         elt = self.SimpleHREF(elt, ps, 'boolean')
  1068.         if not elt:
  1069.             return None
  1070.         
  1071.         if self.nilled(elt, ps):
  1072.             return Nilled
  1073.         
  1074.         v = self.simple_value(elt, ps).lower()
  1075.         return self.text_to_data(v, elt, ps)
  1076.  
  1077.     
  1078.     def get_formatted_content(self, pyobj):
  1079.         if pyobj:
  1080.             return 'true'
  1081.         
  1082.         return 'false'
  1083.  
  1084.  
  1085.  
  1086. class XML(TypeCode):
  1087.     copyit = 0
  1088.     logger = _GetLogger('ZSI.TC.XML')
  1089.     
  1090.     def __init__(self, pname = None, comments = 0, inline = 0, wrapped = True, **kw):
  1091.         TypeCode.__init__(self, pname, **kw)
  1092.         self.comments = comments
  1093.         self.inline = inline
  1094.         if kw.has_key('resolver'):
  1095.             self.resolver = kw['resolver']
  1096.         
  1097.         self.wrapped = wrapped
  1098.         self.copyit = kw.get('copyit', XML.copyit)
  1099.  
  1100.     
  1101.     def parse(self, elt, ps):
  1102.         if self.wrapped is False:
  1103.             return elt
  1104.         
  1105.         c = _child_elements(elt)
  1106.         if not c:
  1107.             href = _find_href(elt)
  1108.             if not href:
  1109.                 if self.minOccurs == 0:
  1110.                     return None
  1111.                 
  1112.                 raise EvaluateException('Embedded XML document missing', ps.Backtrace(elt))
  1113.             
  1114.             if href[0] != '#':
  1115.                 return ps.ResolveHREF(href, self)
  1116.             
  1117.             elt = ps.FindLocalHREF(href, elt)
  1118.             c = _child_elements(elt)
  1119.         
  1120.         if _find_encstyle(elt) != '':
  1121.             pass
  1122.         
  1123.         if len(c) != 1:
  1124.             raise EvaluateException('Embedded XML has more than one child', ps.Backtrace(elt))
  1125.         
  1126.         if self.copyit:
  1127.             return c[0].cloneNode(1)
  1128.         
  1129.         return c[0]
  1130.  
  1131.     
  1132.     def serialize(self, elt, sw, pyobj, name = None, unsuppressedPrefixes = [], **kw):
  1133.         objid = _get_idstr(pyobj)
  1134.         (ns, n) = self.get_name(name, objid)
  1135.         xmlelt = elt
  1136.         if self.wrapped:
  1137.             xmlelt = elt.createAppendElement(ns, n)
  1138.         
  1139.         self.cb(xmlelt, sw, pyobj, unsuppressedPrefixes)
  1140.  
  1141.     
  1142.     def cb(self, elt, sw, pyobj, unsuppressedPrefixes = []):
  1143.         if type(pyobj) in _stringtypes:
  1144.             elt.createAppendTextNode(pyobj)
  1145.             return None
  1146.         
  1147.         doc = elt.getDocument()
  1148.         node = doc.importNode(pyobj, deep = 1)
  1149.         child = elt.node.appendChild(node)
  1150.         parent = pyobj.parentNode
  1151.         while parent.nodeType == _Node.ELEMENT_NODE:
  1152.             for attr in (filter,)((lambda a: if a.name.startswith('xmlns:'):
  1153. passa.name not in child.attributes.keys()), parent.attributes):
  1154.                 child.setAttributeNode(attr.cloneNode(1))
  1155.             
  1156.             parent = parent.parentNode
  1157.  
  1158.  
  1159.  
  1160. class AnyType(TypeCode):
  1161.     all = '#all'
  1162.     other = '#other'
  1163.     type = (SCHEMA.XSD3, 'anyType')
  1164.     logger = _GetLogger('ZSI.TC.AnyType')
  1165.     
  1166.     def __init__(self, pname = None, namespaces = [
  1167.         '#all'], minOccurs = 1, maxOccurs = 1, strip = 1, **kw):
  1168.         TypeCode.__init__(self, pname = pname, minOccurs = minOccurs, maxOccurs = maxOccurs, **kw)
  1169.         self.namespaces = namespaces
  1170.  
  1171.     
  1172.     def get_formatted_content(self, pyobj):
  1173.         what = getattr(pyobj, 'typecode', Any())
  1174.         return what.get_formatted_content(pyobj)
  1175.  
  1176.     
  1177.     def text_to_data(self, text, elt, ps):
  1178.         return text
  1179.  
  1180.     
  1181.     def serialize(self, elt, sw, pyobj, **kw):
  1182.         (nsuri, typeName) = _get_xsitype(pyobj)
  1183.         if self.all not in self.namespaces and nsuri not in self.namespaces:
  1184.             raise EvaluateException('<anyType> unsupported use of namespaces "%s"' % self.namespaces)
  1185.         
  1186.         what = getattr(pyobj, 'typecode', None)
  1187.         if what is None:
  1188.             what = Any(pname = (self.nspname, self.pname), unique = True, aslist = False)
  1189.             kw['typed'] = True
  1190.             what.serialize(elt, sw, pyobj, **kw)
  1191.             return None
  1192.         
  1193.         if not self.nspname:
  1194.             pass
  1195.         if not self.pname:
  1196.             pass
  1197.         what.serialize(elt, sw, pyobj, name = (what.nspname, what.pname), **kw)
  1198.  
  1199.     
  1200.     def parse(self, elt, ps):
  1201.         (nspname, pname) = _get_element_nsuri_name(elt)
  1202.         if nspname != self.nspname or pname != self.pname:
  1203.             raise EvaluateException('<anyType> instance is (%s,%s) found (%s,%s)' % (self.nspname, self.pname, nspname, pname), ps.Backtrace(elt))
  1204.         
  1205.         (prefix, typeName) = SplitQName(_find_type(elt))
  1206.         namespaceURI = _resolve_prefix(elt, prefix)
  1207.         pyclass = GTD(namespaceURI, typeName)
  1208.         if not pyclass:
  1209.             if _is_xsd_or_soap_ns(namespaceURI):
  1210.                 pyclass = Any
  1211.             elif str(namespaceURI).lower() == str(Apache.Map.type[0]).lower() and str(typeName).lower() == str(Apache.Map.type[1]).lower():
  1212.                 pyclass = Apache.Map
  1213.             else:
  1214.                 pyobj = Any().parse_into_dict_or_list(elt, ps)
  1215.                 return pyobj
  1216.         
  1217.         what = pyclass(pname = (self.nspname, self.pname))
  1218.         pyobj = what.parse(elt, ps)
  1219.         return pyobj
  1220.  
  1221.  
  1222.  
  1223. class AnyElement(AnyType):
  1224.     tag = (SCHEMA.XSD3, 'any')
  1225.     logger = _GetLogger('ZSI.TC.AnyElement')
  1226.     
  1227.     def __init__(self, namespaces = [
  1228.         '#all'], pname = None, minOccurs = 1, maxOccurs = 1, strip = 1, processContents = 'strict', **kw):
  1229.         if processContents not in ('lax', 'skip', 'strict'):
  1230.             raise ValueError('processContents(%s) must be lax, skip, or strict')
  1231.         
  1232.         self.processContents = processContents
  1233.         AnyType.__init__(self, namespaces = namespaces, pname = pname, minOccurs = minOccurs, maxOccurs = maxOccurs, strip = strip, **kw)
  1234.  
  1235.     
  1236.     def serialize(self, elt, sw, pyobj, **kw):
  1237.         if isinstance(pyobj, TypeCode):
  1238.             raise TypeError, 'pyobj is a typecode instance.'
  1239.         
  1240.         what = getattr(pyobj, 'typecode', None)
  1241.         if what is not None and type(pyobj) is types.InstanceType:
  1242.             tc = pyobj.__class__
  1243.             what = Any.serialmap.get(tc)
  1244.             if not what:
  1245.                 tc = (types.ClassType, pyobj.__class__.__name__)
  1246.                 what = Any.serialmap.get(tc)
  1247.             
  1248.         
  1249.         self.logger.debug('processContents: %s', self.processContents)
  1250.         if what is None:
  1251.             what = Any(pname = (self.nspname, self.pname))
  1252.         
  1253.         self.logger.debug('serialize with %s', what.__class__.__name__)
  1254.         what.serialize(elt, sw, pyobj, **kw)
  1255.  
  1256.     
  1257.     def parse(self, elt, ps):
  1258.         skip = self.processContents == 'skip'
  1259.         (nspname, pname) = _get_element_nsuri_name(elt)
  1260.         what = GED(nspname, pname)
  1261.         if not skip and what is not None:
  1262.             pyobj = what.parse(elt, ps)
  1263.             
  1264.             try:
  1265.                 pyobj.typecode = what
  1266.             except AttributeError:
  1267.                 ex = None
  1268.                 pyobj = WrapImmutable(pyobj, what)
  1269.  
  1270.             return pyobj
  1271.         
  1272.         (prefix, typeName) = SplitQName(_find_type(elt))
  1273.         if not skip and typeName:
  1274.             if not prefix:
  1275.                 pass
  1276.             namespaceURI = _resolve_prefix(elt, 'xmlns')
  1277.             if not GTD(namespaceURI, typeName):
  1278.                 pass
  1279.             pyclass = Any
  1280.             what = pyclass(pname = (nspname, pname))
  1281.             pyobj = what.parse(elt, ps)
  1282.             
  1283.             try:
  1284.                 pyobj.typecode = what
  1285.             except AttributeError:
  1286.                 ex = None
  1287.                 pyobj = WrapImmutable(pyobj, what)
  1288.  
  1289.             what.typed = True
  1290.             return pyobj
  1291.         
  1292.         if skip:
  1293.             what = XML(pname = (nspname, pname), wrapped = False)
  1294.         elif self.processContents == 'lax':
  1295.             what = Any(pname = (nspname, pname), unique = True)
  1296.         else:
  1297.             what = Any(pname = (nspname, pname), unique = True)
  1298.         
  1299.         try:
  1300.             pyobj = what.parse(elt, ps)
  1301.         except EvaluateException:
  1302.             ex = None
  1303.             self.logger.debug('error parsing:  %s' % str(ex))
  1304.             if len(_children(elt)) != 0:
  1305.                 self.logger.debug('parse <any>, return as dict')
  1306.                 return Any(aslist = False).parse_into_dict_or_list(elt, ps)
  1307.             
  1308.             self.logger.debug('Give up, parse (%s,%s) as a String', what.nspname, what.pname)
  1309.             what = String(pname = (nspname, pname), typed = False)
  1310.             return WrapImmutable(what.parse(elt, ps), what)
  1311.  
  1312.         if pyobj is None:
  1313.             return None
  1314.         
  1315.         if type(pyobj) is dict:
  1316.             return pyobj
  1317.         
  1318.         
  1319.         try:
  1320.             pyobj.typecode = what
  1321.         except AttributeError:
  1322.             pyobj = WrapImmutable(pyobj, what)
  1323.  
  1324.         return pyobj
  1325.  
  1326.  
  1327.  
  1328. class Union(SimpleType):
  1329.     memberTypes = None
  1330.     logger = _GetLogger('ZSI.TC.Union')
  1331.     
  1332.     def __init__(self, pname = None, minOccurs = 1, maxOccurs = 1, **kw):
  1333.         SimpleType.__init__(self, pname = pname, minOccurs = minOccurs, maxOccurs = maxOccurs, **kw)
  1334.         self.memberTypeCodes = []
  1335.  
  1336.     
  1337.     def setMemberTypeCodes(self):
  1338.         if len(self.memberTypeCodes) > 0:
  1339.             return None
  1340.         
  1341.         if self.__class__.memberTypes is None:
  1342.             raise EvaluateException, 'uninitialized class variable memberTypes [(namespace,name),]'
  1343.         
  1344.         for nsuri, name in self.__class__.memberTypes:
  1345.             tcclass = GTD(nsuri, name)
  1346.             if tcclass is None:
  1347.                 if not Any.parsemap.get((nsuri, name)):
  1348.                     pass
  1349.                 tc = Any.parsemap.get((None, name))
  1350.                 typecode = tc.__class__(pname = (self.nspname, self.pname))
  1351.             else:
  1352.                 typecode = tcclass(pname = (self.nspname, self.pname))
  1353.             if typecode is None:
  1354.                 raise EvaluateException, 'Typecode class for Union memberType (%s,%s) is missing' % (nsuri, name)
  1355.             
  1356.             if isinstance(typecode, Struct):
  1357.                 raise EvaluateException, 'Illegal: Union memberType (%s,%s) is complexType' % (nsuri, name)
  1358.             
  1359.             self.memberTypeCodes.append(typecode)
  1360.         
  1361.  
  1362.     
  1363.     def parse(self, elt, ps, **kw):
  1364.         self.setMemberTypeCodes()
  1365.         (nsuri, typeName) = self.checkname(elt, ps)
  1366.         for indx in range(len(self.memberTypeCodes)):
  1367.             typecode = self.memberTypeCodes[indx]
  1368.             
  1369.             try:
  1370.                 pyobj = typecode.parse(elt, ps)
  1371.             except ParseException:
  1372.                 ex = None
  1373.                 continue
  1374.             except Exception:
  1375.                 ex = None
  1376.                 continue
  1377.  
  1378.             if indx > 0:
  1379.                 self.memberTypeCodes.remove(typecode)
  1380.                 self.memberTypeCodes.insert(0, typecode)
  1381.             
  1382.         else:
  1383.             raise 
  1384.         return pyobj
  1385.  
  1386.     
  1387.     def get_formatted_content(self, pyobj, **kw):
  1388.         self.setMemberTypeCodes()
  1389.         for indx in range(len(self.memberTypeCodes)):
  1390.             typecode = self.memberTypeCodes[indx]
  1391.             
  1392.             try:
  1393.                 content = typecode.get_formatted_content(copy.copy(pyobj))
  1394.             except (ParseException, TypeError):
  1395.                 pass
  1396.  
  1397.             if indx > 0:
  1398.                 self.memberTypeCodes.remove(typecode)
  1399.                 self.memberTypeCodes.insert(0, typecode)
  1400.                 continue
  1401.         else:
  1402.             raise 
  1403.         return content
  1404.  
  1405.  
  1406.  
  1407. class List(SimpleType):
  1408.     itemType = None
  1409.     logger = _GetLogger('ZSI.TC.List')
  1410.     
  1411.     def __init__(self, pname = None, itemType = None, **kw):
  1412.         SimpleType.__init__(self, pname = pname, **kw)
  1413.         if not itemType:
  1414.             pass
  1415.         self.itemType = self.itemType
  1416.         self.itemTypeCode = self.itemType
  1417.         itemTypeCode = None
  1418.         if type(self.itemTypeCode) in _seqtypes:
  1419.             (namespaceURI, name) = self.itemTypeCode
  1420.             
  1421.             try:
  1422.                 itemTypeCode = GTD(*self.itemType)(None)
  1423.             except:
  1424.                 if _is_xsd_or_soap_ns(namespaceURI) is False:
  1425.                     raise 
  1426.                 
  1427.                 for pyclass in TYPES:
  1428.                     if pyclass.type == self.itemTypeCode:
  1429.                         itemTypeCode = pyclass(None)
  1430.                         break
  1431.                         continue
  1432.                     if pyclass.type[1] == name:
  1433.                         itemTypeCode = pyclass(None)
  1434.                         continue
  1435.                 
  1436.                 if itemTypeCode is None:
  1437.                     raise EvaluateException('Failed to locate %s' % str(self.itemTypeCode))
  1438.                 
  1439.  
  1440.             if hasattr(itemTypeCode, 'text_to_data') is False:
  1441.                 raise EvaluateException('TypeCode class %s missing text_to_data method' % itemTypeCode)
  1442.             
  1443.             self.itemTypeCode = itemTypeCode
  1444.         
  1445.  
  1446.     
  1447.     def text_to_data(self, text, elt, ps):
  1448.         v = []
  1449.         items = text.split()
  1450.         for item in items:
  1451.             v.append(self.itemTypeCode.text_to_data(item, elt, ps))
  1452.         
  1453.         if self.pyclass is not None:
  1454.             return self.pyclass(v)
  1455.         
  1456.         return v
  1457.  
  1458.     
  1459.     def parse(self, elt, ps):
  1460.         self.checkname(elt, ps)
  1461.         if len(_children(elt)) == 0:
  1462.             href = _find_href(elt)
  1463.             if not href:
  1464.                 if self.nilled(elt, ps) is False:
  1465.                     return []
  1466.                 
  1467.                 if self.nillable is True:
  1468.                     return Nilled
  1469.                 
  1470.                 raise EvaluateException('Required string missing', ps.Backtrace(elt))
  1471.             
  1472.             if href[0] != '#':
  1473.                 return ps.ResolveHREF(href, self)
  1474.             
  1475.             elt = ps.FindLocalHREF(href, elt)
  1476.             self.checktype(elt, ps)
  1477.         
  1478.         if self.nilled(elt, ps):
  1479.             return Nilled
  1480.         
  1481.         if len(_children(elt)) == 0:
  1482.             return []
  1483.         
  1484.         v = self.simple_value(elt, ps)
  1485.         return self.text_to_data(v, elt, ps)
  1486.  
  1487.     
  1488.     def serialize(self, elt, sw, pyobj, name = None, orig = None, **kw):
  1489.         if pyobj is not None and type(pyobj) not in _seqtypes:
  1490.             raise EvaluateException, 'expecting a list or None'
  1491.         
  1492.         objid = _get_idstr(pyobj)
  1493.         (ns, n) = self.get_name(name, objid)
  1494.         el = elt.createAppendElement(ns, n)
  1495.         if self.nillable is True and pyobj is None:
  1496.             self.serialize_as_nil(el)
  1497.             return None
  1498.         
  1499.         tc = self.itemTypeCode
  1500.         s = StringIO()
  1501.         sep = ' '
  1502.         for item in pyobj:
  1503.             s.write(tc.get_formatted_content(item))
  1504.             s.write(sep)
  1505.         
  1506.         el.createAppendTextNode(s.getvalue())
  1507.  
  1508.  
  1509.  
  1510. def RegisterType(C, clobber = 0, *args, **keywords):
  1511.     instance = apply(C, args, keywords)
  1512.     for t in C.__dict__.get('parselist', []):
  1513.         prev = Any.parsemap.get(t)
  1514.         if prev:
  1515.             if prev.__class__ == C:
  1516.                 continue
  1517.             
  1518.             if not clobber:
  1519.                 raise TypeError(str(C) + ' duplicating parse registration for ' + str(t))
  1520.             
  1521.         
  1522.         Any.parsemap[t] = instance
  1523.     
  1524.     for t in C.__dict__.get('seriallist', []):
  1525.         ti = type(t)
  1526.         if ti in [
  1527.             types.TypeType,
  1528.             types.ClassType]:
  1529.             key = t
  1530.         elif ti in _stringtypes:
  1531.             key = (types.ClassType, t)
  1532.         else:
  1533.             raise TypeError(str(t) + ' is not a class name')
  1534.         prev = Any.serialmap.get(key)
  1535.         if prev:
  1536.             if prev.__class__ == C:
  1537.                 continue
  1538.             
  1539.             if not clobber:
  1540.                 raise TypeError(str(C) + ' duplicating serial registration for ' + str(t))
  1541.             
  1542.         
  1543.         Any.serialmap[key] = instance
  1544.     
  1545.  
  1546. from TCnumbers import *
  1547. from TCtimes import *
  1548. from schema import GTD, GED, WrapImmutable
  1549. from TCcompound import *
  1550. from TCapache import *
  1551. (_get_type_definition, _get_global_element_declaration, Wrap) = (GTD, GED, WrapImmutable)
  1552.  
  1553. f = lambda x: if type(x) == types.ClassType and issubclass(x, TypeCode):
  1554. passgetattr(x, 'type', None) is not None
  1555. TYPES = filter(f, map((lambda y: eval(y)), dir()))
  1556. if __name__ == '__main__':
  1557.     print _copyright
  1558.  
  1559.